BCI NET 2/BCI NET 2.iso/archives/programming/gui/precog2_1.lha/Precognition2_1/src/src.lha/Precognition/array.c

C/C++ Source or Header | 1994-12-08 | 5.3 KB | 305 lines

#include "array.h"
#include <stdlib.h>
#include <stdio.h>
#include <stdarg.h>
#include <string.h>
#include <assert.h>

#ifndef NULL
#define NULL (void*)0
#endif

#define ALLOCSTRUCT(name) (struct name*) malloc(sizeof(struct name))

void
initArray( Array *array, int length )
{
   array->vec       = NULL;
   array->length    = 0;
   array->allocsize = 0;
   setLengthOfArray( array, length );
}


Array *
newArray( int length )
{
   struct Array *array;

   if( array = ALLOCSTRUCT( Array ) )
   {
      initArray( array, length );
   }
   return array;
}

void
freeArray( Array *array )
{
   if( array )
   {
      if( array->vec )
      {
         if( array->dtor )
         {
            doToAllInArray( array, array->dtor );
         }
         free( array->vec );
      }
      free( array );
   }
}

void
setArrayDestructor( Array *array, ArrayDtor dtor )
{
   assert( (int)array );

   array->dtor = dtor;
}


int
setLengthOfArray( Array *array, int newlength ) /* returns length */
{
   int newsize;

   assert( (int)array );

   newsize = newlength * sizeof( VOIDPTR );

   array->length = newlength;

   if( newsize <= array->allocsize )
      return array->length;

   if( array->allocsize == 0 ) array->allocsize = 1;
   while( array->allocsize < newsize )
      array->allocsize *= 2;

   if( array->vec == NULL )
   {
      array->vec = (VOIDPTR *)calloc( array->allocsize, 1 );
   }
   else
   {
      array->vec = (VOIDPTR *)realloc( array->vec, array->allocsize );
   }
   return array->length;
}

int
appendToArray( Array *array, const VOIDPTR elt )     /* returns length */
{
   assert( (int)array );
/*printf( "appendToArray: setting length...\n" );*/
   setLengthOfArray( array, array->length+1 );
/*printf( "appendToArray: setting elt\n" );*/
   array->vec[array->length-1] = elt;
/*printf("appendToArray: done\n");*/
   return array->length;
}

int
deleteFromArray( Array *array, int i )          /* returns length */
{
   assert( (int)array );

   if( i < array->length )
   {
      if( ( array->dtor ) && ( array->vec[i] ) )
      {
         (*array->dtor)( array->vec[i] );
      }
      array->vec[i] = NULL;

      array->length--;

      for( ; i < array->length; i++ )
         array->vec[i] = array->vec[ i + 1 ];
   }
   return array->length;
}

int
deleteItemFromArray( Array *array, const VOIDPTR item )
{
   int i;

   i = arrayIndexOfItem( array, item );
   if( i >= 0 )
   {
      deleteFromArray( array, i );
   }
   return array->length;
}

void
doToAllInArray( const Array *array, void (*func)(VOIDPTR) )
{
   int i;

   assert( (int)array );
   assert( (int)func );

   for( i = 0; i < array->length; i++ )
   {
      if( array->vec[i] )
         (*func)( array->vec[i] );
   }
}

int
arrayIndexOfItem( const Array *array, const VOIDPTR *item )
{
   int i;

   assert( (int)array );

   for( i = 0; i < array->length; i++ )
   {
      if( item == array->vec[i] ) return i;
   }
   return -1;
}

int
arrayIndexOfItem2( const Array *array, const VOIDPTR *item, comparer func )
{
   int i;

   assert( (int)array );

   for( i = 0; i < array->length; i++ )
   {
      if( (*func)( item, array->vec[i] ) == 0 ) return i;
   }
   return -1;
}

int
arrayIndexOfString( const Array *array, const char *string )
{
   return arrayIndexOfItem2( array, (const VOIDPTR)string, (comparer)strcmp );
}


int
appendToArrayIfAbsent( Array *array, const VOIDPTR item )
{
   int i;

   i = arrayIndexOfItem( array, item );

   if( i < 0 )
      return appendToArray( array, item );
   else
      return 0;
}

int
appendToArrayIfAbsent2( Array *array, const VOIDPTR item, comparer func )
{
   int i;

   i = arrayIndexOfItem2( array,item, func );

   if( i < 0 )
      return appendToArray( array, item );
   else
      return 0;
}

int
appendStringToArrayIfAbsent( Array *array, const char *string )
{
   int i;

   i = arrayIndexOfString( array, (const VOIDPTR)string );

   if( i < 0 )
      return appendToArray( array, (const VOIDPTR)string );
   else
      return 0;
}

int
appendArrayToArray( Array *target, const Array *source )
{
   int i;

   assert( (int)target );
   assert( (int)source );

   for( i = 0; i < source->length; i++ )
      appendToArray( target, source->vec[i] );

   return target->length;
}

int
appendArrayToArrayIfAbsent( Array *target, const Array *source )
{
   int i;

   assert( (int)target );
   assert( (int)source );

   for( i = 0; i < source->length; i++ )
      appendToArrayIfAbsent( target, source->vec[i] );

   return target->length;
}

int
appendArrayToArrayIfAbsent2( Array *target, const Array *source, comparer func )
{
   int i;

   assert( (int)target );
   assert( (int)source );

   for( i = 0; i < source->length; i++ )
      appendToArrayIfAbsent2( target, source->vec[i], func );

   return target->length;
}

int
appendStringArrayToArrayIfAbsent( Array *target, const Array *source )
{
   assert( (int)target );
   assert( (int)source );

   return appendArrayToArrayIfAbsent2( target, source, (comparer)strcmp );
}


Array*
newStringArrayA( char **svec )
{
   Array *array;
   int i;

   array = newArray( 0 );
   setArrayDestructor( array, (ArrayDtor)free );

   for( i = 0; svec[i] != NULL; i++ )
   {
      appendToArray( array, svec[i] );
   }
   return array;
}

Array*
newStringArray( char *s1, ... )
{
   va_list ap;

   va_start( ap, s1 );
   va_end( ap );

   return newStringArrayA( &s1 );
}